import random  # used for generating large scale random data

# imports
import pytest  # used for our unit tests
from workload import AlexNet

# unit tests

# 1. Basic Test Cases

def test_forward_basic_small_positive_integers():
    # x = [1, 2, 3], features = [1, 4, 9], output = [1, 4, 9]
    model = AlexNet(num_classes=1000)
    codeflash_output = model.forward([1, 2, 3]); result = codeflash_output # 1.53μs -> 391ns (292% faster)

def test_forward_basic_small_negative_integers():
    # x = [-1, -2, -3], features = [1, 4, 9], output = [1, 4, 9]
    model = AlexNet(num_classes=1000)
    codeflash_output = model.forward([-1, -2, -3]); result = codeflash_output # 1.36μs -> 361ns (278% faster)

def test_forward_basic_floats():
    # x = [1.5, 2.0], features = [2.25, 4.0], output = [2, 4]
    model = AlexNet(num_classes=1000)
    codeflash_output = model.forward([1.5, 2.0]); result = codeflash_output # 1.31μs -> 350ns (275% faster)

def test_forward_basic_empty_input():
    # x = [], features = [], output = []
    model = AlexNet(num_classes=1000)
    codeflash_output = model.forward([]); result = codeflash_output # 1.31μs -> 350ns (275% faster)

def test_forward_basic_different_num_classes():
    # x = [32, 33], features = [1024, 1089], output = [24, 39] for num_classes=100
    model = AlexNet(num_classes=100)
    codeflash_output = model.forward([32, 33]); result = codeflash_output # 1.29μs -> 341ns (279% faster)


# 2. Edge Test Cases

def test_forward_edge_zero():
    # x = [0], features = [0], output = [0]
    model = AlexNet(num_classes=1000)
    codeflash_output = model.forward([0]); result = codeflash_output # 1.26μs -> 341ns (270% faster)

def test_forward_edge_large_number():
    # x = [99999], features = [9999800001], output = [9999800001 % 1000]
    model = AlexNet(num_classes=1000)
    codeflash_output = model.forward([99999]); result = codeflash_output # 1.27μs -> 330ns (285% faster)

def test_forward_edge_negative_and_positive_mix():
    # x = [-2, 0, 2], features = [4, 0, 4], output = [4, 0, 4]
    model = AlexNet(num_classes=1000)
    codeflash_output = model.forward([-2, 0, 2]); result = codeflash_output # 1.31μs -> 340ns (286% faster)



def test_forward_edge_num_classes_one():
    # x = [1, 2, 3], num_classes=1, all outputs should be 0
    model = AlexNet(num_classes=1)
    codeflash_output = model.forward([1, 2, 3]); result = codeflash_output # 1.60μs -> 421ns (281% faster)

def test_forward_edge_num_classes_negative():
    # x = [2], num_classes=-3, should work as Python's % works with negatives
    model = AlexNet(num_classes=-3)
    codeflash_output = model.forward([2]); result = codeflash_output # 1.40μs -> 331ns (324% faster)

def test_forward_edge_float_num_classes():
    # x = [2], num_classes=2.5, should work as Python's % works with floats
    model = AlexNet(num_classes=2.5)
    codeflash_output = model.forward([2]); result = codeflash_output # 1.32μs -> 341ns (288% faster)


def test_forward_large_scale_1000_elements():
    # x = list(range(1000)), features = [i*i for i in range(1000)], output = [i*i % 1000 for i in range(1000)]
    model = AlexNet(num_classes=1000)
    x = list(range(1000))
    expected = [i * i % 1000 for i in x]
    codeflash_output = model.forward(x); result = codeflash_output # 1.62μs -> 441ns (268% faster)

def test_forward_large_scale_random_floats():
    # Random floats between -100 and 100, 1000 elements
    model = AlexNet(num_classes=1000)
    random.seed(42)
    x = [random.uniform(-100, 100) for _ in range(1000)]
    expected = [int(item ** 2) % 1000 for item in x]
    codeflash_output = model.forward(x); result = codeflash_output # 1.50μs -> 380ns (296% faster)

def test_forward_large_scale_large_numbers():
    # Large numbers, to check for overflow or performance issues
    model = AlexNet(num_classes=999983)
    x = [10**6 + i for i in range(1000)]
    expected = [((10**6 + i) ** 2) % 999983 for i in range(1000)]
    codeflash_output = model.forward(x); result = codeflash_output # 1.38μs -> 381ns (263% faster)

def test_forward_large_scale_all_zeros():
    # Large input, all zeros
    model = AlexNet(num_classes=1000)
    x = [0] * 1000
    expected = [0] * 1000
    codeflash_output = model.forward(x); result = codeflash_output # 1.32μs -> 360ns (267% faster)

def test_forward_large_scale_all_same_number():
    # Large input, all same number
    model = AlexNet(num_classes=1000)
    x = [7] * 1000
    expected = [49 % 1000] * 1000
    codeflash_output = model.forward(x); result = codeflash_output # 1.25μs -> 321ns (290% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.